home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / cpufreq.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.9 KB  |  386 lines
  1. /*
  2.  *  linux/include/linux/cpufreq.h
  3.  *
  4.  *  Copyright (C) 2001 Russell King
  5.  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
  6.  *            
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 2 as
  9.  * published by the Free Software Foundation.
  10.  */
  11. #ifndef _LINUX_CPUFREQ_H
  12. #define _LINUX_CPUFREQ_H
  13.  
  14. #include <linux/mutex.h>
  15. #include <linux/notifier.h>
  16. #include <linux/threads.h>
  17. #include <linux/device.h>
  18. #include <linux/kobject.h>
  19. #include <linux/sysfs.h>
  20. #include <linux/completion.h>
  21. #include <linux/workqueue.h>
  22. #include <linux/cpumask.h>
  23. #include <asm/div64.h>
  24.  
  25. #define CPUFREQ_NAME_LEN 16
  26.  
  27.  
  28. /*********************************************************************
  29.  *                     CPUFREQ NOTIFIER INTERFACE                    *
  30.  *********************************************************************/
  31.  
  32. #define CPUFREQ_TRANSITION_NOTIFIER    (0)
  33. #define CPUFREQ_POLICY_NOTIFIER        (1)
  34.  
  35. #ifdef CONFIG_CPU_FREQ
  36. int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
  37. int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
  38. #else        /* CONFIG_CPU_FREQ */
  39. static inline int cpufreq_register_notifier(struct notifier_block *nb,
  40.                         unsigned int list)
  41. {
  42.     return 0;
  43. }
  44. static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
  45.                         unsigned int list)
  46. {
  47.     return 0;
  48. }
  49. #endif        /* CONFIG_CPU_FREQ */
  50.  
  51. /* if (cpufreq_driver->target) exists, the ->governor decides what frequency
  52.  * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
  53.  * two generic policies are available:
  54.  */
  55.  
  56. #define CPUFREQ_POLICY_POWERSAVE    (1)
  57. #define CPUFREQ_POLICY_PERFORMANCE    (2)
  58.  
  59. /* Frequency values here are CPU kHz so that hardware which doesn't run 
  60.  * with some frequencies can complain without having to guess what per 
  61.  * cent / per mille means. 
  62.  * Maximum transition latency is in nanoseconds - if it's unknown,
  63.  * CPUFREQ_ETERNAL shall be used.
  64.  */
  65.  
  66. struct cpufreq_governor;
  67.  
  68. #define CPUFREQ_ETERNAL            (-1)
  69. struct cpufreq_cpuinfo {
  70.     unsigned int        max_freq;
  71.     unsigned int        min_freq;
  72.     unsigned int        transition_latency; /* in 10^(-9) s = nanoseconds */
  73. };
  74.  
  75. struct cpufreq_real_policy {
  76.     unsigned int        min;    /* in kHz */
  77.     unsigned int        max;    /* in kHz */
  78.         unsigned int        policy; /* see above */
  79.     struct cpufreq_governor    *governor; /* see below */
  80. };
  81.  
  82. struct cpufreq_policy {
  83.     cpumask_t        cpus;    /* CPUs requiring sw coordination */
  84.     cpumask_t        related_cpus; /* CPUs with any coordination */
  85.     unsigned int        shared_type; /* ANY or ALL affected CPUs
  86.                         should set cpufreq */
  87.     unsigned int        cpu;    /* cpu nr of registered CPU */
  88.     struct cpufreq_cpuinfo    cpuinfo;/* see above */
  89.  
  90.     unsigned int        min;    /* in kHz */
  91.     unsigned int        max;    /* in kHz */
  92.     unsigned int        cur;    /* in kHz, only needed if cpufreq
  93.                      * governors are used */
  94.         unsigned int        policy; /* see above */
  95.     struct cpufreq_governor    *governor; /* see below */
  96.  
  97.     struct work_struct    update; /* if update_policy() needs to be
  98.                      * called, but you're in IRQ context */
  99.  
  100.     struct cpufreq_real_policy    user_policy;
  101.  
  102.     struct kobject        kobj;
  103.     struct completion    kobj_unregister;
  104. };
  105.  
  106. #define CPUFREQ_ADJUST        (0)
  107. #define CPUFREQ_INCOMPATIBLE    (1)
  108. #define CPUFREQ_NOTIFY        (2)
  109. #define CPUFREQ_START        (3)
  110.  
  111. #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
  112. #define CPUFREQ_SHARED_TYPE_HW     (1) /* HW does needed coordination */
  113. #define CPUFREQ_SHARED_TYPE_ALL     (2) /* All dependent CPUs should set freq */
  114. #define CPUFREQ_SHARED_TYPE_ANY     (3) /* Freq can be set from any dependent CPU*/
  115.  
  116. /******************** cpufreq transition notifiers *******************/
  117.  
  118. #define CPUFREQ_PRECHANGE    (0)
  119. #define CPUFREQ_POSTCHANGE    (1)
  120. #define CPUFREQ_RESUMECHANGE    (8)
  121. #define CPUFREQ_SUSPENDCHANGE    (9)
  122.  
  123. struct cpufreq_freqs {
  124.     unsigned int cpu;    /* cpu nr */
  125.     unsigned int old;
  126.     unsigned int new;
  127.     u8 flags;        /* flags of cpufreq_driver, see below. */
  128. };
  129.  
  130.  
  131. /**
  132.  * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe)
  133.  * @old:   old value
  134.  * @div:   divisor
  135.  * @mult:  multiplier
  136.  *
  137.  *
  138.  *    new = old * mult / div
  139.  */
  140. static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult)
  141. {
  142. #if BITS_PER_LONG == 32
  143.  
  144.     u64 result = ((u64) old) * ((u64) mult);
  145.     do_div(result, div);
  146.     return (unsigned long) result;
  147.  
  148. #elif BITS_PER_LONG == 64
  149.  
  150.     unsigned long result = old * ((u64) mult);
  151.     result /= div;
  152.     return result;
  153.  
  154. #endif
  155. };
  156.  
  157. /*********************************************************************
  158.  *                          CPUFREQ GOVERNORS                        *
  159.  *********************************************************************/
  160.  
  161. #define CPUFREQ_GOV_START  1
  162. #define CPUFREQ_GOV_STOP   2
  163. #define CPUFREQ_GOV_LIMITS 3
  164.  
  165. struct cpufreq_governor {
  166.     char    name[CPUFREQ_NAME_LEN];
  167.     int     (*governor)    (struct cpufreq_policy *policy,
  168.                  unsigned int event);
  169.     ssize_t    (*show_setspeed)    (struct cpufreq_policy *policy,
  170.                      char *buf);
  171.     int     (*store_setspeed)    (struct cpufreq_policy *policy,
  172.                      unsigned int freq);
  173.     unsigned int max_transition_latency; /* HW must be able to switch to
  174.             next freq faster than this value in nano secs or we
  175.             will fallback to performance governor */
  176.     struct list_head    governor_list;
  177.     struct module        *owner;
  178. };
  179.  
  180. /* pass a target to the cpufreq driver 
  181.  */
  182. extern int cpufreq_driver_target(struct cpufreq_policy *policy,
  183.                  unsigned int target_freq,
  184.                  unsigned int relation);
  185. extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
  186.                    unsigned int target_freq,
  187.                    unsigned int relation);
  188.  
  189.  
  190. extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy,
  191.                    unsigned int cpu);
  192.  
  193. int cpufreq_register_governor(struct cpufreq_governor *governor);
  194. void cpufreq_unregister_governor(struct cpufreq_governor *governor);
  195.  
  196. int lock_policy_rwsem_read(int cpu);
  197. int lock_policy_rwsem_write(int cpu);
  198. void unlock_policy_rwsem_read(int cpu);
  199. void unlock_policy_rwsem_write(int cpu);
  200.  
  201.  
  202. /*********************************************************************
  203.  *                      CPUFREQ DRIVER INTERFACE                     *
  204.  *********************************************************************/
  205.  
  206. #define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
  207. #define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
  208.  
  209. struct freq_attr;
  210.  
  211. struct cpufreq_driver {
  212.     struct module           *owner;
  213.     char            name[CPUFREQ_NAME_LEN];
  214.     u8            flags;
  215.  
  216.     /* needed by all drivers */
  217.     int    (*init)        (struct cpufreq_policy *policy);
  218.     int    (*verify)    (struct cpufreq_policy *policy);
  219.  
  220.     /* define one out of two */
  221.     int    (*setpolicy)    (struct cpufreq_policy *policy);
  222.     int    (*target)    (struct cpufreq_policy *policy,
  223.                  unsigned int target_freq,
  224.                  unsigned int relation);
  225.  
  226.     /* should be defined, if possible */
  227.     unsigned int    (*get)    (unsigned int cpu);
  228.  
  229.     /* optional */
  230.     unsigned int (*getavg)    (struct cpufreq_policy *policy,
  231.                  unsigned int cpu);
  232.  
  233.     int    (*exit)        (struct cpufreq_policy *policy);
  234.     int    (*suspend)    (struct cpufreq_policy *policy, pm_message_t pmsg);
  235.     int    (*resume)    (struct cpufreq_policy *policy);
  236.     struct freq_attr    **attr;
  237. };
  238.  
  239. /* flags */
  240.  
  241. #define CPUFREQ_STICKY        0x01    /* the driver isn't removed even if 
  242.                      * all ->init() calls failed */
  243. #define CPUFREQ_CONST_LOOPS     0x02    /* loops_per_jiffy or other kernel
  244.                      * "constants" aren't affected by
  245.                      * frequency transitions */
  246. #define CPUFREQ_PM_NO_WARN    0x04    /* don't warn on suspend/resume speed
  247.                      * mismatches */
  248.  
  249. int cpufreq_register_driver(struct cpufreq_driver *driver_data);
  250. int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
  251.  
  252.  
  253. void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state);
  254.  
  255.  
  256. static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 
  257. {
  258.     if (policy->min < min)
  259.         policy->min = min;
  260.     if (policy->max < min)
  261.         policy->max = min;
  262.     if (policy->min > max)
  263.         policy->min = max;
  264.     if (policy->max > max)
  265.         policy->max = max;
  266.     if (policy->min > policy->max)
  267.         policy->min = policy->max;
  268.     return;
  269. }
  270.  
  271. struct freq_attr {
  272.     struct attribute attr;
  273.     ssize_t (*show)(struct cpufreq_policy *, char *);
  274.     ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
  275. };
  276.  
  277.  
  278. /*********************************************************************
  279.  *                        CPUFREQ 2.6. INTERFACE                     *
  280.  *********************************************************************/
  281. int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
  282. int cpufreq_update_policy(unsigned int cpu);
  283.  
  284. /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */
  285. unsigned int cpufreq_get(unsigned int cpu);
  286.  
  287. /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */
  288. #ifdef CONFIG_CPU_FREQ
  289. unsigned int cpufreq_quick_get(unsigned int cpu);
  290. #else
  291. static inline unsigned int cpufreq_quick_get(unsigned int cpu)
  292. {
  293.     return 0;
  294. }
  295. #endif
  296.  
  297.  
  298. /*********************************************************************
  299.  *                       CPUFREQ DEFAULT GOVERNOR                    *
  300.  *********************************************************************/
  301.  
  302.  
  303. /*
  304.   Performance governor is fallback governor if any other gov failed to
  305.   auto load due latency restrictions
  306. */
  307. #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
  308. extern struct cpufreq_governor cpufreq_gov_performance;
  309. #endif
  310. #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
  311. #define CPUFREQ_DEFAULT_GOVERNOR    (&cpufreq_gov_performance)
  312. #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
  313. extern struct cpufreq_governor cpufreq_gov_powersave;
  314. #define CPUFREQ_DEFAULT_GOVERNOR    (&cpufreq_gov_powersave)
  315. #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
  316. extern struct cpufreq_governor cpufreq_gov_userspace;
  317. #define CPUFREQ_DEFAULT_GOVERNOR    (&cpufreq_gov_userspace)
  318. #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
  319. extern struct cpufreq_governor cpufreq_gov_ondemand;
  320. #define CPUFREQ_DEFAULT_GOVERNOR    (&cpufreq_gov_ondemand)
  321. #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
  322. extern struct cpufreq_governor cpufreq_gov_conservative;
  323. #define CPUFREQ_DEFAULT_GOVERNOR    (&cpufreq_gov_conservative)
  324. #endif
  325.  
  326.  
  327. /*********************************************************************
  328.  *                     FREQUENCY TABLE HELPERS                       *
  329.  *********************************************************************/
  330.  
  331. #define CPUFREQ_ENTRY_INVALID ~0
  332. #define CPUFREQ_TABLE_END     ~1
  333.  
  334. struct cpufreq_frequency_table {
  335.     unsigned int    index;     /* any */
  336.     unsigned int    frequency; /* kHz - doesn't need to be in ascending
  337.                     * order */
  338. };
  339.  
  340. int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
  341.                     struct cpufreq_frequency_table *table);
  342.  
  343. int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
  344.                    struct cpufreq_frequency_table *table);
  345.  
  346. int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
  347.                    struct cpufreq_frequency_table *table,
  348.                    unsigned int target_freq,
  349.                    unsigned int relation,
  350.                    unsigned int *index);
  351.  
  352. /* the following 3 funtions are for cpufreq core use only */
  353. struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
  354. struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
  355. void   cpufreq_cpu_put (struct cpufreq_policy *data);
  356.  
  357. /* the following are really really optional */
  358. extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
  359.  
  360. void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 
  361.                       unsigned int cpu);
  362.  
  363. void cpufreq_frequency_table_put_attr(unsigned int cpu);
  364.  
  365.  
  366. /*********************************************************************
  367.  *                     UNIFIED DEBUG HELPERS                         *
  368.  *********************************************************************/
  369.  
  370. #define CPUFREQ_DEBUG_CORE    1
  371. #define CPUFREQ_DEBUG_DRIVER    2
  372. #define CPUFREQ_DEBUG_GOVERNOR    4
  373.  
  374. #ifdef CONFIG_CPU_FREQ_DEBUG
  375.  
  376. extern void cpufreq_debug_printk(unsigned int type, const char *prefix, 
  377.                  const char *fmt, ...);
  378.  
  379. #else
  380.  
  381. #define cpufreq_debug_printk(msg...) do { } while(0)
  382.  
  383. #endif /* CONFIG_CPU_FREQ_DEBUG */
  384.  
  385. #endif /* _LINUX_CPUFREQ_H */
  386.